<?php

class Pagina {
//<editor-fold defaultstate="collapsed" desc="Constantes">
  const NOMBRE_ENTIDAD = "Pagina";
  const SESION_PAGINA_INICIO = "PaginaInicio";
  const SESION_ID_PAGINA_MENU_SELECCIONADA = "IdPaginaMenu";
  //indice arreglos
  const ARRAY_PAGINA_DETALLE = 0;
  const ARRAY_PAGINA_LISTADO_FUNCIONES = 1;
  const ARRAY_PAGINA_LISTADO_PERFILES_NO_PERTENECE = 2;
  const ARRAY_PAGINA_LISTADO_PERFILES_SI_PERTENECE = 3;

//</editor-fold>

//<editor-fold defaultstate="collapsed" desc="Campos">
  private $_id;
  private $_titulo;
  private $_modulo;
  private $_nombreClase;
  private $_orden;
  private $_activo;
  private $_mostrarEnMenu;
  private $_idCategoria;
  private $_existe;
//</editor-fold>

//<editor-fold defaultstate="collapsed" desc="Propiedades">
  public function getId() { return $this->_id; }
  public function setId($value) { $this->_id = $value; }

  public function getTitulo() { return $this->_titulo; }
  public function setTitulo($value) { $this->_titulo = $value; }

  public function getModulo() { return $this->_modulo; }
  public function setModulo($value) { $this->_modulo = $value; }

  public function getNombreClase() { return $this->_nombreClase; }
  public function setNombreClase($value) { $this->_nombreClase = $value; }

  public function getOrden() { return $this->_orden; }
  public function setOrden($value) { $this->_orden = $value; }

  public function getActivo() { return $this->_activo; }
  public function setActivo($value) { $this->_activo = $value; }

  public function getMostrarEnMenu() { return $this->_mostrarEnMenu; }
  public function setMostrarEnMenu($value) { $this->_mostrarEnMenu = $value; }

  public function getIdCategoria() { return $this->_idCategoria; }
  public function setIdCategoria($value) { $this->_idCategoria = $value; }

  public function getExiste() { return $this->_existe; }
  public function setExiste($value) { $this->_existe = $value; }
//</editor-fold>
  
//<editor-fold defaultstate="collapsed" desc="Metodos Publicos">
  /**
   * constructor
   * @author VSR, 01/01/2011
   */
  public function __construct($id = -1) {
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Pagina_ObtenerPorId({id});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{id}", $id, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
      $totalRegistros = count($arr);

      //si se encontraron registros entonces se asignan
      if ($totalRegistros > 0) {
        $row = $arr[0];
        $this->_id = ( is_null($row["Id"]) ) ? -1 : $row["Id"];
        $this->_titulo = ( is_null($row["Titulo"]) ) ? "" : $row["Titulo"];
        $this->_modulo = ( is_null($row["Modulo"]) ) ? "" : $row["Modulo"];
        $this->_nombreClase = ( is_null($row["NombreClase"]) ) ? "" : $row["NombreClase"];
        $this->_orden = ( is_null($row["Orden"]) ) ? 0 : $row["Orden"];
        $this->_activo = ( is_null($row["Activo"]) ) ? 0 : $row["Activo"];
        $this->_mostrarEnMenu = ( is_null($row["MostrarEnMenu"]) ) ? 0 : $row["MostrarEnMenu"];
        $this->_idCategoria = ( is_null($row["IdCategoria"]) ) ? -1 : $row["IdCategoria"];
        $this->_existe = ($this->_id == -1) ? 0 : 1;
      } else {
        $this->_id = -1;
        $this->_titulo = "";
        $this->_modulo = "";
        $this->_nombreClase = "";
        $this->_orden = 0;
        $this->_activo = 0;
        $this->_mostrarEnMenu = 0;
        $this->_idCategoria = -1;
        $this->_existe = 0;
      }
    } catch (Exception $e) {
      throw new Exception($e->getMessage());
    }
  }

  /**
   * crea o actualiza un registro
   * @author VSR, 01/01/2011
   */
  public function grabar() {
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Pagina_Grabar({id},'{titulo}','{modulo}','{nombreClase}',{orden},{activo},{mostrarEnMenu},{idCategoria});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{id}", $this->_id, $sp);
      $sp = str_replace("{titulo}", $this->_titulo, $sp);
      $sp = str_replace("{modulo}", $this->_modulo, $sp);
      $sp = str_replace("{nombreClase}", $this->_nombreClase, $sp);
      $sp = str_replace("{orden}", $this->_orden, $sp);
      $sp = str_replace("{activo}", $this->_activo, $sp);
      $sp = str_replace("{mostrarEnMenu}", $this->_mostrarEnMenu, $sp);
      $sp = str_replace("{idCategoria}", $this->_idCategoria, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
      $totalRegistros = count($arr);

      //si se encontraron registros entonces se asignan
      if ($totalRegistros > 0) {
        $row = $arr[0];
        $this->_id = $row["Id"];
        $this->_existe = 1;
      } else {
        $this->_id = -1;
        $this->_existe = 0;
      }
    } catch (Exception $e) {
      throw new Exception($e->getMessage());
    }
  }

  /**
   * elimina un registro
   * @author VSR, 01/01/2011
   */
  public function eliminar() {
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Pagina_Eliminar({id});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{id}", $this->_id, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
      $totalRegistros = count($arr);

      //si se encontraron registros entonces se asignan
      $this->_id = -1;
      $this->_existe = 0;
    } catch (Exception $e) {
      throw new Exception($e->getMessage());
    }
  }

  /**
   * destructor
   * @author VSR, 01/01/2011
   */
  public function  __destruct() {
   // destruye el objeto
  }
//</editor-fold>

//<editor-fold defaultstate="collapsed" desc="Metodos Compartidos">
  /**
   * obtiene listado de paginas
   * @param <type> $idUsuario
   * @param <type> $filtroNombre
   * @param <type> $filtroCategoria
   * @author VSR, 01/01/2011
   */
  public static function obtenerListadoConFiltro($idUsuario, $filtroNombre, $filtroCategoria, $filtroModulo) {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Pagina_ObtenerListadoConFiltro({idUsuario},'{filtroNombre}','{filtroCategoria}','{filtroModulo}');";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idUsuario}", $idUsuario, $sp);
      $sp = str_replace("{filtroNombre}", $filtroNombre, $sp);
      $sp = str_replace("{filtroCategoria}", $filtroCategoria, $sp);
      $sp = str_replace("{filtroModulo}", $filtroModulo, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);

    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

  /**
   * obtiene detalle de la pagina consultada
   * @param <type> $idPagina
   * @return string
   * @author VSR, 01/01/2011
   */
  public static function obtenerDetalle($idPagina) {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Pagina_ObtenerDetalle({idPagina});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idPagina}", $idPagina, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp, Bd::MULTI_QUERY);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

  /**
   * Obtiene Listado de categorias para poder autocompletar la busqueda
   * @param <type> $texto
   * @return string
   * @author VSR, 01/01/2011
   */
  public static function autocompletarCategoria($texto) {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Pagina_AutocompletarCategoria('{texto}');";

      //reemplaza marcas por valores reales
      $sp = str_replace("{texto}", $texto, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

  /**
   * Obtiene Listado de modulo para poder autocompletar la busqueda
   * @param <type> $texto
   * @return string
   * @author VSR, 01/01/2011
   */
  public static function autocompletarModulo($texto) {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Pagina_AutocompletarModulo('{texto}');";

      //reemplaza marcas por valores reales
      $sp = str_replace("{texto}", $texto, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

  /**
   * graba los datos de una pagina
   * @param <type> $idPagina
   * @param <type> $titulo
   * @param <type> $modulo
   * @param <type> $nombreClase
   * @param <type> $nombreCategoria
   * @param <type> $activo
   * @param <type> $mostrarEnMenu
   * @param <type> $listadoIdPerfiles
   * @return string
   * @author VSR, 01/01/2011
   */
  public static function grabarDatos($idPagina, $titulo, $modulo, $nombreClase, $nombreCategoria, $activo, $mostrarEnMenu, $listadoIdPerfiles) {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Pagina_GrabarDatos({idPagina},'{titulo}','{modulo}','{nombreClase}','{nombreCategoria}',{activo},{mostrarEnMenu},'{listadoIdPerfiles}');";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idPagina}", $idPagina, $sp);
      $sp = str_replace("{titulo}", $titulo, $sp);
      $sp = str_replace("{modulo}", $modulo, $sp);
      $sp = str_replace("{nombreClase}", $nombreClase, $sp);
      $sp = str_replace("{nombreCategoria}", $nombreCategoria, $sp);
      $sp = str_replace("{activo}", $activo, $sp);
      $sp = str_replace("{mostrarEnMenu}", $mostrarEnMenu, $sp);
      $sp = str_replace("{listadoIdPerfiles}", $listadoIdPerfiles, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

  /**
   * modifica los datos de una pagina
   * @param <type> $idPagina
   * @param <type> $titulo
   * @param <type> $modulo
   * @param <type> $nombreArchivo
   * @param <type> $nombreCategoria
   * @param <type> $estado
   * @param <type> $mostrarEnMenu
   * @param <type> $listadoIdPerfiles
   * @return string
   * @author VSR, 01/01/2011
   */
  public static function modificarDatos($idPagina, $titulo, $modulo, $nombreClase, $nombreCategoria, $activo, $mostrarEnMenu, $listadoIdPerfiles) {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Pagina_ModificarDatos({idPagina},'{titulo}','{modulo}','{nombreClase}','{nombreCategoria}',{activo},{mostrarEnMenu},'{listadoIdPerfiles}');";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idPagina}", $idPagina, $sp);
      $sp = str_replace("{titulo}", $titulo, $sp);
      $sp = str_replace("{modulo}", $modulo, $sp);
      $sp = str_replace("{nombreClase}", $nombreClase, $sp);
      $sp = str_replace("{nombreCategoria}", $nombreCategoria, $sp);
      $sp = str_replace("{activo}", $activo, $sp);
      $sp = str_replace("{mostrarEnMenu}", $mostrarEnMenu, $sp);
      $sp = str_replace("{listadoIdPerfiles}", $listadoIdPerfiles, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

  /**
   * determina si un valor ya existe en base de datos para la pagina seleccionada
   * @param <type> $idPagina
   * @param <type> $valor
   * @param <type> $campoARevisar
   * @return string
   * @author VSR, 01/01/2011
   */
  public static function verificarDuplicidad($idPagina, $valor, $campoARevisar) {
    $estaDuplicado = "0";

    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Pagina_VerificarDuplicidad$campoARevisar({idPagina}, '{valor}');";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idPagina}", $idPagina, $sp);
      $sp = str_replace("{valor}", $valor, $sp);

      //ejecuta procedimiento
      $estaDuplicado = Bd::exec($sp, Bd::SCALAR);
    } catch (Exception $e) {
      $estaDuplicado = "0";
    }
    return $estaDuplicado;
  }

  /**
   * elimina las funciones que no esten en la lista
   * @param <type> $idPagina
   * @param <type> $listadoIdFuncion
   * @return <type>
   * @author VSR, 01/01/2011
   */
  public static function eliminarFuncionesNoExistentes($idPagina, $listadoIdFuncion) {
    $retorno = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Pagina_EliminarFuncionesNoExistentes({idPagina},'{listadoIdFuncion}');";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idPagina}", $idPagina, $sp);
      $sp = str_replace("{listadoIdFuncion}", $listadoIdFuncion, $sp);

      //ejecuta procedimiento
      $retorno = Bd::exec($sp, Bd::SCALAR);
    } catch (Exception $e) {
      $retorno = Sistema::CODIGO_SQL_ERROR;
    }
    return $retorno;
  }

  /**
   * graba o actualiza una funcion de una pagina
   * @param <type> $idPagina
   * @param <type> $idFuncion
   * @param <type> $nombre
   * @param <type> $llave
   * @param <type> $orden
   * @return string
   * @author VSR, 01/01/2011
   */
  public static function grabarFuncion($idPagina, $idFuncion, $nombre, $llave, $orden) {
    $retorno = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Pagina_GrabarFuncion({idPagina},{idFuncion},'{nombre}','{llave}',{orden});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idPagina}", $idPagina, $sp);
      $sp = str_replace("{idFuncion}", $idFuncion, $sp);
      $sp = str_replace("{nombre}", $nombre, $sp);
      $sp = str_replace("{llave}", $llave, $sp);
      $sp = str_replace("{orden}", $orden, $sp);

      //ejecuta procedimiento
      $retorno = Bd::exec($sp, Bd::SCALAR, Bd::ORIGEN_DATOS_DEFAULT ,"Status");
    } catch (Exception $e) {
      $retorno = Sistema::CODIGO_SQL_ERROR;
    }
    return $retorno;
  }

  /**
   * verifica si se puede eliminar la funcion al tener referencias asociadas
   * @param <type> $idFuncion
   * @return <type>
   * @author VSR, 01/01/2011
   */
  public static function verificarEliminacionFuncion($idFuncion) {
    $retorno = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Pagina_VerificarEliminacionFuncion({idFuncion});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idFuncion}", $idFuncion, $sp);

      //ejecuta procedimiento
      $retorno = Bd::exec($sp, Bd::SCALAR, Bd::ORIGEN_DATOS_DEFAULT ,"Status");
    } catch (Exception $e) {
      $retorno = Sistema::CODIGO_SQL_ERROR;
    }
    return $retorno;
  }

  /**
   * elimina una pagina
   * @param <type> $idPagina
   * @return <type>
   * @author VSR, 01/01/2011
   */
  public static function eliminarDatos($idPagina) {
    $retorno = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Pagina_EliminarDatos({idPagina});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idPagina}", $idPagina, $sp);

      //ejecuta procedimiento
      $retorno = Bd::exec($sp, Bd::SCALAR, Bd::ORIGEN_DATOS_DEFAULT ,"Status");
    } catch (Exception $e) {
      $retorno = Sistema::CODIGO_SQL_ERROR;
    }
    return $retorno;
  }

//</editor-fold>

}

?>

